/*============================================================================*/
/*  Copyright (C) 2009-2011, iSOFT INFRASTRUCTURE SOFTWARE CO.,LTD.
 *
 *  All rights reserved. This software is iSOFT property. Duplication
 *  or disclosure without iSOFT written authorization is prohibited.
 *
 *
 *  @file       <Com.h>
 *  @brief      <Declear the Data_Types, Global variable & Functions of Com Module>
 *
 *  <Compiler: MinGW20120426    MCU:XXX>
 *
 *  @author     <Dongliang.Chen>
 *  @date       <17-02-2014>
 */
/*============================================================================*/
#ifndef  COM_H
#define  COM_H

/*=======[R E V I S I O N   H I S T O R Y]====================================*/
/*  <VERSION>    <DATE>    <AUTHOR>    <REVISION LOG>
 *  V1.0.0     20140217  Dongliang.Chen Initial version
 *                                      Add Requirements of AutoSAR Com 4.0 R1 As followed:
 *                                      COM578_Conf
 *                                      COM650, COM651, COM124, COM652, COM725, COM691, COM654,
 *                                      COM655, COM656, COM657, COM721, COM692, COM658, COM693,
 *                                      COM663
 *  V1.0.1     20140717  Dongliang.Chen 1. Fixed: COM_UPDATEBIT_ENABLE Macro Control Problem
 *                                         mark: DLCOMH201401
 *                                      2. Fixed: COM_FILTER_ENABLE Macro Control Problem
 *                                         mark: DLCOMH201402
 *                                      3. Fixed: COM_GATEWAY_ENABLE Macro Control Problem
 *                                         mark: DLCOMH201403
 *  V1.0.2     20140814  Dongliang.Chen 1. Add: Com_Gateway Rx IPdu Id Array
 *                                         mark: DLCOMH201404
 *                                      2. Add: Because Destination Description Add Filter.
 *                                         mark: DLCOMH201405
 *                                      3. Modify: FilterFunc Number is different base on Gateway Macro
 *                                                 Control.
 *                                         mark: DLCOMH201406
 *                                      4. Add: An array of Com_GwTxIPduIdPB.
 *                                         mark: DLCOMH201407
 *                                      5. Delete U in #if
 *                                         whole code file
 *                                      6. Add Com_GwMapToTxGrpSigId Array for RxGrpSig Map To TxGrpSig.
 *                                         mark: DLCOMH201408
 *                                      7. Modify: API ID Macro.
 *                                         mark: DLCOMH201409
 *                                      8. Modify: Com_TxMode MemMap.
 *                                         mark: DLCOMH201410
 *  V1.0.3     20141027  Dongliang.Chen 1. Add: Com_TxSignalInitTMC, Com_TxGroupSignalInitTMC, Com_DestDescripInitTMC
 *                                              Three arrays.
 *                                         mark: DLCOMH201411
 *  V1.0.4     20141208  Dongliang.Chen 1. Add: COM_VERSION_INFO_API Macro Control Com_GetVersionInfo
 *                                         mark: DLCOMH201412
 *
 */
/*============================================================================*/

/*=======[V E R S I O N  I N F O R M A T I O N]===============================*/
#define COM_VENDOR_ID               62U
#define COM_MODULE_ID               50U
#define COM_H_AR_MAJOR_VERSION      3U
#define COM_H_AR_MINOR_VERSION      2U
#define COM_H_AR_PATCH_VERSION      0U
#define COM_H_SW_MAJOR_VERSION      1U
#define COM_H_SW_MINOR_VERSION      0U
#define COM_H_SW_PATCH_VERSION      4U

/*=======[I N C L U D E S]====================================================*/
#include "Com_Types.h"
#include "Com_Cfg.h"

#if((COM_VARIANT_LT == COM_VARIANT_CFG) || (COM_VARIANT_PB== COM_VARIANT_CFG))
#include "Com_Lcfg.h"
#endif

#if(COM_VARIANT_PB== COM_VARIANT_CFG)
#include "Com_PBcfg.h"
#endif


/*=======[M A C R O S]========================================================*/
#define COM_INSTANCE_ID                             ((uint8)0x00U)

/* Service Id of COM_Functions */
#define COMSERVICEID_COPYTXDATA                      ((uint8)0x24U)
#define COMSERVICEID_COPYRXDATA                      ((uint8)0x23U)
#define COMSERVICEID_STARTOFRECEPTION                ((uint8)0x25U)
#define COMSERVICEID_TPTXCONFIRMATION                ((uint8)0x26U)
#define COMSERVICEID_TPRXINDICATION                  ((uint8)0x1EU)
#define COMSERVICEID_INVALIDATESIGNALGROUP           ((uint8)0x1BU)
#define COMSERVICEID_MAINFUNCTIONROUTESIGNALS        ((uint8)0x1AU)
#define COMSERVICEID_MAINFUNCTIONTX                  ((uint8)0x19U)
#define COMSERVICEID_MAINFUNCTIONRX                  ((uint8)0x18U)
#define COMSERVICEID_TRIGGERIPDUSEND                 ((uint8)0x17U)
#define COMSERVICEID_INVALIDATESHADOWSIGNAL          ((uint8)0x16U)
#define COMSERVICEID_TXCONFIRMATION                  ((uint8)0x15U)
#define COMSERVICEID_RXINDICATION                    ((uint8)0x14U)
#define COMSERVICEID_TRIGGERTRANSMIT                 ((uint8)0x13U)
#define COMSERVICEID_ERRORGETSERVICEID               ((uint8)0x11U)
#define COMSERVICEID_INVALIDATESIGNAL                ((uint8)0x10U)
#define COMSERVICEID_RECEIVESHADOWSIGNAL             ((uint8)0x0FU)
#define COMSERVICEID_RECEIVESIGNALGROUP              ((uint8)0x0EU)
#define COMSERVICEID_SENDSIGNALGROUP                 ((uint8)0x0DU)
#define COMSERVICEID_UPDATESHADOWSIGNAL              ((uint8)0x0CU)
#define COMSERVICEID_RECEIVESIGNAL                   ((uint8)0x0BU)
#define COMSERVICEID_SENDSIGNAL                      ((uint8)0x0AU)
#define COMSERVICEID_GETVERSIONINFO                  ((uint8)0x09U)
#define COMSERVICEID_GETCONFIRGURATIONID             ((uint8)0x08U)
#define COMSERVICEID_GETSTATUS                       ((uint8)0x07U)
/* DLCOMH201409 */
#define COMSERVICEID_DISALERECEPTIONDM               ((uint8)0x05U)
#define COMSERVICEID_ENABLERECEPTIONDM               ((uint8)0x06U)
/* DLCOMH201409 */
#define COMSERVICEID_IPDUGROUPSTOP                   ((uint8)0x04U)
#define COMSERVICEID_IPDUGROUPSTART                  ((uint8)0x03U)
#define COMSERVICEID_DEINIT                          ((uint8)0x02U)
#define COMSERVICEID_INIT                            ((uint8)0x01U)

/* Enumeration of Com_StatusType */
#define COM_UNINIT         0x00
#define COM_INIT           0x01

/* Return Codes, API service is currently not available e.g. the corresponding
 * I-PDU group is stopped (or a development error has been detected) */
#define COM_SERVICE_NOT_AVAILABLE                    ((uint8)0x80U)

/* A timeout has occurred */
#define COM_TIMEOUT                                  ((uint8)0x81U)

/* DET Error Detection */
#define COM_E_PARAM                   ((uint8)0x01U)
#define COM_E_UNINIT                  ((uint8)0x02U)

/* Mark Id in GwMap is Description((Com_SignalIdType)0x8000U) or not */
#define COM_GWMAP_DESCRIPTION_MARK    ((Com_SignalIdType)0x8000U)

#define COM_INDEX_DEFAULT             ((uint16)0xFFFFU)

#define COM_FILTER_FUNC_ALWAY_INDEX        ((uint8)0x0000U)
#define COM_FILTER_FUNC_NEVER_INDEX        ((uint8)0x0001U)


/* DLCOMH201406 */
#if(STD_ON == COM_GATEWAY_ENABLE)
/* Filter Function Number */
#define COM_FILTER_FUNC_NUM                         ((uint8)38U)
#else
/* Filter Function Number */
#define COM_FILTER_FUNC_NUM                         ((uint8)29U)
#endif


/* Com_RxFOneEveryN Function Index */
#define COM_RXFILTER_ONEN_FUNCINDEX                 ((uint8)6U)
/* Com_TxSigFOneEveryN Function Index */
#define COM_TXSIGFILTER_ONEN_FUNCINDEX              ((uint8)19U)
/* Com_TxGSFOneEveryN Function Index */
#define COM_TXGSFILTER_ONEN_FUNCINDEX               ((uint8)20U)
/* Com_DestinationDescription OneEveryN FilterFunction Index */
#define COM_DESTDESCFILTER_ONEN_FUNCINDEX           ((uint8)(0xFFFFU))
/* Need old Value Rx_Filter_Function Start Index */
#define COM_RXFILTER_OLDVALFNC_START                ((uint8)7U)
/* Need old Value Rx_Filter_Function End Index */
#define COM_RXFILTER_OLDVALFNC_END                  ((uint8)10U)

#define COM_32BITARRAY_NUM                          ((uint8)33U)

#define COM_SUPPORT_IPDUGROUP_NUM                   ((uint8)64U)

/*==========[M A C R O  F U N C T I O N S]====================================*/
/******************************************************************************/
/*
 * Brief               Provides the unique identifier of the configuration.
 * ServiceId           0x09
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint32: configured ConfigurationID.
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
/* DLCOMH201412 */
#if (STD_ON == COM_VERSION_INFO_API)
/* DLCOMH201412 */
#if (STD_ON == COM_DEV_ERROR_DETECT)
#define Com_GetVersionInfo(VersionInfo) \
    do{\
        if (NULL_PTR == (VersionInfo))\
        {\
            Det_ReportError(COM_MODULE_ID, COM_INSTANCE_ID, COMSERVICEID_GETVERSIONINFO, COM_E_PARAM);\
        }\
        else \
        {\
            (VersionInfo)->vendorID = COM_VENDOR_ID; \
            (VersionInfo)->moduleID = COM_MODULE_ID; \
            (VersionInfo)->instanceID = 0u; \
            (VersionInfo)->sw_major_version = COM_H_SW_MAJOR_VERSION; \
            (VersionInfo)->sw_minor_version = COM_H_SW_MINOR_VERSION; \
            (VersionInfo)->sw_patch_version = COM_H_SW_PATCH_VERSION; \
        }\
    }while(0)
#else
#define Com_GetVersionInfo(VersionInfo) \
    do{\
          (VersionInfo)->vendorID = COM_VENDOR_ID; \
          (VersionInfo)->moduleID = COM_MODULE_ID; \
          (VersionInfo)->instanceID = 0u; \
          (VersionInfo)->sw_major_version = COM_H_SW_MAJOR_VERSION; \
          (VersionInfo)->sw_minor_version = COM_H_SW_MINOR_VERSION; \
          (VersionInfo)->sw_patch_version = COM_H_SW_PATCH_VERSION; \
    }while(0)
#endif
/* DLCOMH201412 */
#endif
/* DLCOMH201412 */

/*=======[T Y P E   D E F I N I T I O N S]====================================*/

/*=======[E X T E R N A L   D A T A]==========================================*/
#if (COM_IPDUCALLOUT_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_CallOutFnc, COM_CONST) IPdu_CalloutFnc[COM_IPDUCALLOUT_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_CallOutFnc, COM_CONST, COM_CONST) IPdu_CalloutFnc;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif


#if (COM_VARIANT_PC== COM_VARIANT_CFG)
/* Config of IPdu */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_IPduGroupPBType, COM_CONST_PBCFG) Com_IPduGroupPB[COM_IPDUGROUP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#if (COM_RXIPDU_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_RxIPduPBType, COM_CONST_PBCFG) Com_RxIPduPB[COM_RXIPDU_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_RxIPduCOutFuncIndexLTType, COM_CONST) Com_RxIPduCalloutLT[COM_RXIPDU_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxIPduPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxIPduPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxIPduCOutFuncIndexLTType, COM_CONST, COM_CONST) Com_RxIPduCalloutLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if(COM_RXIPDUIDMAP_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(PduIdType, COM_CONST_PBCFG) Com_RxIPduIdMapPB[COM_RXIPDUIDMAP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(PduIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxIPduIdMapPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

#if (COM_TXIPDU_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_TxIPduPBType, COM_CONST_PBCFG) Com_TxIPduPB[COM_TXIPDU_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxIPduCOutFuncIndexLTType, COM_CONST) Com_TxIPduCalloutLT[COM_TXIPDU_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxIPduPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxIPduPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxIPduCOutFuncIndexLTType, COM_CONST, COM_CONST) Com_TxIPduCalloutLT;
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if(COM_TXIPDUIDMAP_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(PduIdType, COM_CONST_PBCFG) Com_TxIPduIdMapPB[COM_TXIPDUIDMAP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(PduIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxIPduIdMapPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

/* Config of Signal */
#if (COM_RXSIGNAL_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_RxSignalPBType, COM_CONST_PBCFG) Com_RxSignalPB[COM_RXSIGNAL_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_RxSignalLTType, COM_CONST) Com_RxSignalLT[COM_RXSIGNAL_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxSignalPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxSignalLTType, COM_CONST, COM_CONST) Com_RxSignalLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXSIGNAL_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_TxSignalPBType, COM_CONST_PBCFG) Com_TxSignalPB[COM_TXSIGNAL_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxSignalLTType, COM_CONST) Com_TxSignalLT[COM_TXSIGNAL_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxSignalPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxSignalPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxSignalLTType, COM_CONST, COM_CONST) Com_TxSignalLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Config of SignalGroup */
#if (COM_RXSIGNALGROUP_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_RxSignalGroupPBType, COM_CONST_PBCFG) Com_RxSignalGroupPB[COM_RXSIGNALGROUP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_RxSignalGroupLTType, COM_CONST) Com_RxSignalGroupLT[COM_RXSIGNALGROUP_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxSignalGroupPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalGroupPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxSignalGroupLTType, COM_CONST, COM_CONST) Com_RxSignalGroupLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXSIGNALGROUP_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_TxSignalGroupPBType, COM_CONST_PBCFG) Com_TxSignalGroupPB[COM_TXSIGNALGROUP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxSignalGroupLTType, COM_CONST) Com_TxSignalGroupLT[COM_TXSIGNALGROUP_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxSignalGroupPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxSignalGroupPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxSignalGroupLTType, COM_CONST, COM_CONST) Com_TxSignalGroupLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Config of GroupSignal */
#if (COM_RXGROUPSIGNAL_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_RxGroupSignalPBType, COM_CONST_PBCFG) Com_RxGroupSignalPB[COM_RXGROUPSIGNAL_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_RxGroupSignalLTType, COM_CONST) Com_RxGroupSignalLT[COM_RXGROUPSIGNAL_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxGroupSignalPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxGroupSignalPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_RxGroupSignalLTType, COM_CONST, COM_CONST) Com_RxGroupSignalLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXGROUPSIGNAL_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_TxGroupSignalPBType, COM_CONST_PBCFG) Com_TxGroupSignalPB[COM_TXGROUPSIGNAL_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxGroupSignalLTType, COM_CONST) Com_TxGroupSignalLT[COM_TXGROUPSIGNAL_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxGroupSignalPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxGroupSignalPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"

#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxGroupSignalLTType, COM_CONST, COM_CONST) Com_TxGroupSignalLT;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Config of Filter */
#if (STD_ON == COM_FILTER_ENABLE)
#if (COM_FILTER_PARAMARRAY_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_FilterType, COM_CONST) Com_Filter[COM_FILTER_PARAMARRAY_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_FilterType, COM_CONST, COM_CONST) Com_Filter;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif    /* STD_ON == COM_FILTER_ENABLE */

/* Config of Com_TxMode */
/* DLCOMH201410 */
#if (COM_TXMODE_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxModeType, COM_CONST_PBCFG) Com_TxMode[COM_TXMODE_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxModeType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxMode;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
/* DLCOMH201410 */

/* Config of GW */
#if (STD_ON == COM_GATEWAY_ENABLE)
/* DLCOMH201404 */
#if (COM_GWRXIPDU_BUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(PduIdType, COM_CONST_PBCFG) Com_GwRxIPduIdPB[COM_GWRXIPDU_BUFF_SIZE];
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(PduIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_GwRxIPduIdPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif
/* DLCOMH201407 */
#if (COM_GWTXIPDU_BUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(PduIdType, COM_CONST_PBCFG) Com_GwTxIPduIdPB[COM_GWTXIPDU_BUFF_SIZE];
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(PduIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_GwTxIPduIdPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif
/* DLCOMH201407 */

#if (COM_SRCDESC_NUMBER > 0)
/* Config of GwSrcDesc */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_GwSourceDescripPBType, COM_CONST_PBCFG) Com_SrcDescPB[COM_SRCDESC_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_GwSourceDescripPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_SrcDescPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

#if (COM_DESTDESC_NUMBER > 0)
/* Config of GwDestDesc */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_GwDestDescripPBType, COM_CONST_PBCFG) Com_DestDescPB[COM_DESTDESC_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_GwDestDescripPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_DestDescPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

#if (COM_SIGGWMAP_NUMBER > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
/* Config GwMapping Source, Signal & Description */
extern CONST(Com_SignalGwMapPBType, COM_CONST_PBCFG) Com_SignalGwMapPB[COM_SIGGWMAP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalGwMapPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_SignalGwMapPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

#if (COM_SGROUPGWMAP_NUMBER > 0)
/* Config GwMapping Source, only SignalGroup */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_SignalGroupGwMapPBType, COM_CONST_PBCFG) Com_SGroupGwMapPB[COM_SGROUPGWMAP_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalGroupGwMapPBType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_SGroupGwMapPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

#if (COM_GWDESTID_NUMBER > 0)
/* Config of GwDestIDArray */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_SignalIdType, COM_CONST_PBCFG) Com_GwDestIdPB[COM_GWDESTID_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_GwDestIdPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif

/* DLCOMH201408 */
#if (COM_GWTXGRPSIG_NUMBER > 0)
/* Config of GwDestIDArray */
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(Com_SignalIdType, COM_CONST_PBCFG) Com_GwMapRxGrpSigToTxGrpSigIdPB[COM_GWTXGRPSIG_NUMBER];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_GwMapRxGrpSigToTxGrpSigIdPB;
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#endif
/* DLCOMH201408 */
#endif /* STD_ON == COM_GATEWAY_ENABLE */

/* Config of Invalid Value */
#if (COM_BOOLINVALIDVALUE_NUM > 0)
#define COM_START_SEC_CONST_BOOLEAN
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_SignalBoolInvVal[COM_BOOLINVALIDVALUE_NUM];
#define COM_STOP_SEC_CONST_BOOLEAN
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_SignalBoolInvVal;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_8BITINVALIDVALUE_NUM > 0)
#define COM_START_SEC_CONST_8BIT
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_Signal8BitInvVal[COM_8BITINVALIDVALUE_NUM];
#define COM_STOP_SEC_CONST_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal8BitInvVal;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_16BITINVALIDVALUE_NUM > 0)
#define COM_START_SEC_CONST_16BIT
#include "Com_MemMap.h"
extern CONST(uint16, COM_CONST_PBCFG) Com_Signal16BitInvVal[COM_16BITINVALIDVALUE_NUM];
#define COM_STOP_SEC_CONST_16BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint16, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal16BitInvVal;
#define COM_STOP_SEC_CONST_32BIT
#include "Com_MemMap.h"
#endif

#if (COM_32BITINVALIDVALUE_NUM > 0)
#define COM_START_SEC_CONST_32BIT
#include "Com_MemMap.h"
extern CONST(uint32, COM_CONST_PBCFG) Com_Signal32BitInvVal[COM_32BITINVALIDVALUE_NUM];
#define COM_STOP_SEC_CONST_32BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint32, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal32BitInvVal;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Config of IPdu_Init_Value */
#if (COM_RXIPDUBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_RxIPduInitValue[COM_RXIPDUBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxIPduInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXIPDUBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_TxIPduInitValue[COM_TXIPDUBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxIPduInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Data_InitValue */
#if (COM_SIGNAL_BOOLBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_SignalBoolInitValue[COM_SIGNAL_BOOLBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_SignalBoolInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_8BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_Signal8BitInitValue[COM_SIGNAL_8BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal8BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_16BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint16, COM_CONST_PBCFG) Com_Signal16BitInitValue[COM_SIGNAL_16BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint16, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal16BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_32BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint32, COM_CONST_PBCFG) Com_Signal32BitInitValue[COM_SIGNAL_32BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint32, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_Signal32BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* DLCOMH201402 */
#if (STD_ON == COM_FILTER_ENABLE)
#if (COM_TXSIGNALGROUP_TMCCNTR_NUNBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_TxSignalGroupTMCCntType, COM_CONST_PBCFG) Com_TxSignalGroupInitTMCCntr[COM_TXSIGNALGROUP_TMCCNTR_NUNBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_TxSignalGroupTMCCntType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxSignalGroupInitTMCCntr;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */

#if (STD_ON == COM_FILTER_ENABLE)
#if (COM_RXSIGNAL_NOB_BOOLBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_RxSignalNOBBoolInitValue[COM_RXSIGNAL_NOB_BOOLBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalNOBBoolInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_8BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_RxSignalNOB8BitInitValue[COM_RXSIGNAL_NOB_8BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalNOB8BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_16BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint16, COM_CONST_PBCFG) Com_RxSignalNOB16BitInitValue[COM_RXSIGNAL_NOB_16BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint16, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalNOB16BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_32BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint32, COM_CONST_PBCFG) Com_RxSignalNOB32BitInitValue[COM_RXSIGNAL_NOB_32BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint32, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxSignalNOB32BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif

/* Config of Rx_GroupSignal_InitValue */
#if (COM_RXGROUPSIGNAL_BOOLBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_RxGroupSignalBoolInitValue[COM_RXGROUPSIGNAL_BOOLBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxGroupSignalBoolInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_8BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint8, COM_CONST_PBCFG) Com_RxGroupSignal8BitInitValue[COM_RXGROUPSIGNAL_8BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint8, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxGroupSignal8BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_16BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint16, COM_CONST_PBCFG) Com_RxGroupSignal16BitInitValue[COM_RXGROUPSIGNAL_16BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint16, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxGroupSignal16BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_32BITBUFF_SIZE > 0)
#define COM_START_CONST_PBCFG
#include "Com_MemMap.h"
extern CONST(uint32, COM_CONST_PBCFG) Com_RxGroupSignal32BitInitValue[COM_RXGROUPSIGNAL_32BITBUFF_SIZE];
#define COM_STOP_CONST_PBCFG
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(uint32, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxGroupSignal32BitInitValue;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Config of Rx_Signal/Rx_SignalGroup with update-bit */
#if(STD_ON == COM_UPDATEBIT_ENABLE)
#if (COM_SIGNALDM_CNTRBUFF_SIZE)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_SignalIdType, COM_CONST_PBCFG) Com_RxUpdateSignalId[COM_SIGNALDM_CNTRBUFF_SIZE];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxUpdateSignalId;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNALGROUPDM_CNTRBUFF_SIZE)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(Com_SignalGroupIdType, COM_CONST_PBCFG) Com_RxUpdateSignalGrouplId[COM_SIGNALGROUPDM_CNTRBUFF_SIZE];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(Com_SignalGroupIdType, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_RxUpdateSignalGrouplId;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif    /* STD_ON == COM_UPDATEBIT_ENABLE */


/* mark: DLCOMH201411 */
#if(STD_ON == COM_FILTER_ENABLE)
#if(COM_TXSIGNAL_TMCRST_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_TxSignalInitTMC[COM_TXSIGNAL_TMCRST_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxSignalInitTMC;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if(COM_TXGROUPSIGNAL_TMCRST_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_TxGroupSignalInitTMC[COM_TXGROUPSIGNAL_TMCRST_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_TxGroupSignalInitTMC;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if(STD_ON == COM_GATEWAY_ENABLE)
#if(COM_DESTDESCRIPTION_TMCRST_NUMBER > 0)
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONST(boolean, COM_CONST_PBCFG) Com_DestDescripInitTMC[COM_DESTDESCRIPTION_TMCRST_NUMBER];
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
extern CONSTP2CONST(boolean, COM_CONST_PBCFG, COM_CONST_PBCFG) Com_DestDescripInitTMC;
#define COM_STOP_SEC_CONST_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif    /* STD_ON == COM_GATEWAY_ENABLE */

#endif    /* STD_ON == COM_FILTER_ENABLE */
/* mark: DLCOMH201411 */



/* RunTime */

/* RunTime SubIPduGroupActiveFlag, For MainFunction*/
/* extern Com_IPduGroupActFlagRTType Com_SubIPduGrouplag[COM_SUBIPDUGROUP_NUMBER];*/

/* Runtime IPdu Value, Init at Com_Init, Refresh on Rx/Tx */
#if (COM_RXIPDUBUFF_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxIPduRuntimeBuff[COM_RXIPDUBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_RxIPduRunTimeLength[COM_RXIPDU_NUMBER];  /* only Deferred use this Array */
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxIPduRuntimeBuff;
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_RxIPduRunTimeLength;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSINGLEDEFIPDU_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxDefIPduBuff[COM_RXSINGLEDEFIPDU_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxDefIPduBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXIPDUBUFF_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_TxIPduRuntimeBuff[COM_TXIPDUBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_TxIPduRuntimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Runtime No RX_Filter_Signal Value, Init at Com_Init, Refresh on Rx/Tx, All_Rx is at first, All_Tx is at last */
#if (COM_SIGNAL_BOOLBUFF_SIZE > 0)
#define COM_START_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
extern VAR(boolean, COM_VAR) Com_SignalBoolRuntimeBuff[COM_SIGNAL_BOOLBUFF_SIZE];
#define COM_STOP_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(boolean, COM_VAR, AUTOMATIC) Com_SignalBoolRuntimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_8BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_Signal8BitRuntimeBuff[COM_SIGNAL_8BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_Signal8BitRuntimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_16BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_Signal16BitRuntimeBuff[COM_SIGNAL_16BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_Signal16BitRuntimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_SIGNAL_32BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_32BIT
#include "Com_MemMap.h"
extern VAR(uint32, COM_VAR) Com_Signal32BitRuntimeBuff[COM_SIGNAL_32BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_32BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint32, COM_VAR, AUTOMATIC) Com_Signal32BitRuntimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Runtime Rx GroupSignal Value, Init at Com_Init, Refresh on Rx */
/* Runtime Rx SiganlGroup Shadow Buffer, Init at Com_Init, Refresh on Recive_SignalGroup, mapping is same as Com_***_GSRTValue */
#if (COM_RXGROUPSIGNAL_BOOLBUFF_SIZE > 0)
#define COM_START_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
extern VAR(boolean, COM_VAR) Com_RxGroupSignalBoolRtimeBuff[COM_RXGROUPSIGNAL_BOOLBUFF_SIZE];
#define COM_STOP_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
extern VAR(boolean, COM_VAR) Com_RxShadowSignalBoolRTimeBuff[COM_RXGROUPSIGNAL_BOOLBUFF_SIZE];
#define COM_STOP_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(boolean, COM_VAR, AUTOMATIC) Com_RxGroupSignalBoolRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(boolean, COM_VAR, AUTOMATIC) Com_RxShadowSignalBoolRTimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_8BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxGroupSignal8BitRtimeBuff[COM_RXGROUPSIGNAL_8BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxShadowSignal8BitRTimeBuff[COM_RXGROUPSIGNAL_8BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxGroupSignal8BitRtimeBuff;
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxShadowSignal8BitRTimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_16BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_RxGroupSignal16BitRtimeBuff[COM_RXGROUPSIGNAL_16BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_RxShadowSignal16BitRTimeBuff[COM_RXGROUPSIGNAL_16BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_RxGroupSignal16BitRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_RxShadowSignal16BitRTimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXGROUPSIGNAL_32BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_32BIT
#include "Com_MemMap.h"
extern VAR(uint32, COM_VAR) Com_RxGroupSignal32BitRtimeBuff[COM_RXGROUPSIGNAL_32BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_32BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_32BIT
#include "Com_MemMap.h"
extern VAR(uint32, COM_VAR) Com_RxShadowSignal32BitRTimeBuff[COM_RXGROUPSIGNAL_32BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_32BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint32, COM_VAR, AUTOMATIC) Com_RxGroupSignal32BitRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint32, COM_VAR, AUTOMATIC) Com_RxShadowSignal32BitRTimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif


/* Runtime Rx Signal Buffer which filter is F_MaskedNewDiffersMaskedOld & Cfged DM*/
/* NOldB means thate the signal Need Old Buffer */
#if (STD_ON == COM_FILTER_ENABLE)
#if (COM_RXSIGNAL_NOB_BOOLBUFF_SIZE > 0)
#define COM_START_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
extern VAR(boolean, COM_VAR) Com_RxSignalNOBBoolRtimeOldBuff[COM_RXSIGNAL_NOB_BOOLBUFF_SIZE];
#define COM_STOP_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
extern VAR(boolean, COM_VAR) Com_RxSignalNOBBoolRtimeBuff[COM_RXSIGNAL_NOB_BOOLBUFF_SIZE];
#define COM_STOP_SEC_VAR_BOOLEAN
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(boolean, COM_VAR, AUTOMATIC) Com_RxSignalNOBBoolRtimeOldBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(boolean, COM_VAR, AUTOMATIC) Com_RxSignalNOBBoolRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_8BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxSignalNOB8BitRtimeOldBuff[COM_RXSIGNAL_NOB_8BITBUFF_SIZE];  /* old value */
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_8BIT
#include "Com_MemMap.h"
extern VAR(uint8, COM_VAR) Com_RxSignalNOB8BitRtimeBuff[COM_RXSIGNAL_NOB_8BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_8BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxSignalNOB8BitRtimeOldBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint8, COM_VAR, AUTOMATIC) Com_RxSignalNOB8BitRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_16BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_RxSignalNOB16BitRtimeOldBuff[COM_RXSIGNAL_NOB_16BITBUFF_SIZE];   /* old value */
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_16BIT
#include "Com_MemMap.h"
extern VAR(uint16, COM_VAR) Com_RxSignalNOB16BitRtimeBuff[COM_RXSIGNAL_NOB_16BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_16BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_RxSignalNOB16BitRtimeOldBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint16, COM_VAR, AUTOMATIC) Com_RxSignalNOB16BitRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_RXSIGNAL_NOB_32BITBUFF_SIZE > 0)
#define COM_START_SEC_VAR_32BIT
#include "Com_MemMap.h"
extern VAR(uint32, COM_VAR) Com_RxSignalNOB32BitRtimeOldBuff[COM_RXSIGNAL_NOB_32BITBUFF_SIZE];   /* old value */
#define COM_STOP_SEC_VAR_32BIT
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_32BIT
#include "Com_MemMap.h"
extern VAR(uint32, COM_VAR) Com_RxSignalNOB32BitRtimeBuff[COM_RXSIGNAL_NOB_32BITBUFF_SIZE];
#define COM_STOP_SEC_VAR_32BIT
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint32, COM_VAR, AUTOMATIC) Com_RxSignalNOB32BitRtimeOldBuff ;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(uint32, COM_VAR, AUTOMATIC) Com_RxSignalNOB32BitRtimeBuff;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif   /* STD_ON == COM_FILTER_ENABLE */

/* Runtime of Tx/Rx IPdu State */
#if (COM_RXIPDU_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_RxIPduFlagRTType, COM_VAR) Com_RxIPduRTimeFlag[COM_RXIPDU_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_RxIPduRTDMRTType, COM_VAR) Com_RxIPduRTimeDMCntr[COM_RXIPDU_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_RxIPduFlagRTType, COM_VAR, AUTOMATIC) Com_RxIPduRTimeFlag;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_RxIPduRTDMRTType, COM_VAR, AUTOMATIC) Com_RxIPduRTimeDMCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (COM_TXIPDU_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxIPduStateRTType, COM_VAR) Com_TxIPduRTimeState[COM_TXIPDU_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxIPduFlagRTType, COM_VAR) Com_TxIPduRTimeFlag[COM_TXIPDU_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxIPduStateRTType, COM_VAR, AUTOMATIC) Com_TxIPduRTimeState;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxIPduFlagRTType, COM_VAR, AUTOMATIC) Com_TxIPduRTimeFlag;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

/* Runtime TxSignal_with_Filter State */
#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_TXSIGNAL_TMCRST_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxSignalLastTMCRTType, COM_VAR) Com_TxSignalRTimeLastTMC[COM_TXSIGNAL_TMCRST_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXSIGNAL_TMCRST_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxSignalLastTMCRTType, COM_VAR, AUTOMATIC) Com_TxSignalRTimeLastTMC;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_TXSIGNAL_TMCRST_NUMBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */

#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_TXSIGNAL_ONEEVERYN_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_SignalFOccureRTType, COM_VAR) Com_TxSignalRTimeOccurenceCntr[COM_TXSIGNAL_ONEEVERYN_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXSIGNAL_ONEEVERYN_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_SignalFOccureRTType, COM_VAR, AUTOMATIC) Com_TxSignalRTimeOccurenceCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_TXSIGNAL_ONEEVERYN_NUMBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */

#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_TXGRPSIG_ONEEVERYN_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_SignalFOccureRTType, COM_VAR) Com_TxGrpSigRTimeOccurenceCntr[COM_TXGRPSIG_ONEEVERYN_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXGRPSIG_ONEEVERYN_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_SignalFOccureRTType, COM_VAR, AUTOMATIC) Com_TxGrpSigRTimeOccurenceCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_TXGRPSIG_ONEEVERYN_NUMBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */


/* Runtime RxSignal_With_F_OneEveryN State */
#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_RXSIGNAL_ONEEVERYN_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_SignalFOccureRTType, COM_VAR) Com_RxSignalRTimeOccurenceCntr[COM_RXSIGNAL_ONEEVERYN_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_RXSIGNAL_ONEEVERYN_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_SignalFOccureRTType, COM_VAR, AUTOMATIC) Com_RxSignalRTimeOccurenceCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_RXSIGNAL_ONEEVERYN_NUMBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */

/* DLCOMH201405 */
/* Runtime Destination Description with Filter */
#if ((STD_ON == COM_FILTER_ENABLE) && (STD_ON == COM_GATEWAY_ENABLE))
#if (COM_DESTDESCRIPTION_TMCRST_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_DestDescripLastTMCRTType, COM_VAR) Com_DestDescripRTimeLastTMC[COM_DESTDESCRIPTION_TMCRST_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_DestDescripLastTMCRTType, COM_VAR, AUTOMATIC) Com_DestDescripRTimeLastTMC;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif
/* DLCOMH201405 */

/* DLCOMH201405 */
#if ((STD_ON == COM_FILTER_ENABLE) && (STD_ON == COM_GATEWAY_ENABLE))
#if (COM_DESTDESCRIP_ONEEVERYN_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_DestDescripFOccureRTType, COM_VAR) Com_DestDescRTimeOccurenceCntr[COM_DESTDESCRIP_ONEEVERYN_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXSIGNAL_ONEEVERYN_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_DestDescripFOccureRTType, COM_VAR, AUTOMATIC) Com_DestDescRTimeOccurenceCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif
#endif
/* DLCOMH201405 */

/* Runtime update RxSignal State */
#if (STD_ON == COM_UPDATEBIT_ENABLE)
/* DLCOMH201401 */
#if (COM_SIGNALDM_CNTRBUFF_SIZE > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_RxUpdateSignalDMRTType, COM_VAR) Com_RxUpdateSignalRTimeDMCntr[COM_SIGNALDM_CNTRBUFF_SIZE];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_SIGNALDM_CNTRBUFF_SIZE > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_RxUpdateSignalDMRTType, COM_VAR, AUTOMATIC) Com_RxUpdateSignalRTimeDMCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_SIGNALDM_CNTRBUFF_SIZE > 0u */
/* DLCOMH201401 */
#endif    /* STD_ON == COM_UPDATEBIT_ENABLE */

/* Runtime TxSignalGroup State */
#if (COM_TXSIGNALGROUP_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxSignalGroupFlagRTType, COM_VAR) Com_TxSigGrpRTimeFlag[COM_TXSIGNALGROUP_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxSignalGroupFlagRTType, COM_VAR, AUTOMATIC) Com_TxSigGrpRTimeFlag;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif

#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_TXSIGNALGROUP_TMCCNTR_NUNBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxSignalGroupTMCCntType, COM_VAR) Com_TxSignalGroupRTimeTMCCntr[COM_TXSIGNALGROUP_TMCCNTR_NUNBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxSignalGroupLastTMCRTType, COM_VAR) Com_TxSignalGroupRTimeLastTMC[COM_TXSIGNALGROUP_TMCCNTR_NUNBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXSIGNALGROUP_TMCCNTR_NUNBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxSignalGroupTMCCntType, COM_VAR, AUTOMATIC) Com_TxSignalGroupRTimeTMCCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"

#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxSignalGroupLastTMCRTType, COM_VAR, AUTOMATIC) Com_TxSignalGroupRTimeLastTMC;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_TXSIGNALGROUP_TMCCNTR_NUNBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */

/* Runtime update RxSignalGroup State */
#if (STD_ON == COM_UPDATEBIT_ENABLE)
/* DLCOMH201401 */
#if (COM_SIGNALGROUPDM_CNTRBUFF_SIZE > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_RxUpdateSignalGroupDMRTType, COM_VAR) Com_RxUpdateSigGrpRTimeDMCntr[COM_SIGNALGROUPDM_CNTRBUFF_SIZE];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_SIGNALGROUPDM_CNTRBUFF_SIZE > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_RxUpdateSignalGroupDMRTType, COM_VAR, AUTOMATIC) Com_RxUpdateSigGrpRTimeDMCntr;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_SIGNALGROUPDM_CNTRBUFF_SIZE > 0u */
/* DLCOMH201401 */
#endif    /* STD_ON == COM_UPDATEBIT_ENABLE */


/* RunTime Type, Tx_GroupSignal_Runtime */
#if (STD_ON == COM_FILTER_ENABLE)
/* DLCOMH201402 */
#if (COM_TXGROUPSIGNAL_TMCRST_NUMBER > 0)
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern VAR(Com_TxGroupSignalLastTMCRTType, COM_VAR) Com_TxGrpSigRTimeLastTMC[COM_TXGROUPSIGNAL_TMCRST_NUMBER];
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#else    /* COM_TXGROUPSIGNAL_TMCRST_NUMBER > 0u */
#define COM_START_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
extern P2VAR(Com_TxGroupSignalLastTMCRTType, COM_VAR, AUTOMATIC) Com_TxGrpSigRTimeLastTMC;
#define COM_STOP_SEC_VAR_UNSPECIFIED
#include "Com_MemMap.h"
#endif    /* COM_TXGROUPSIGNAL_TMCRST_NUMBER > 0u */
/* DLCOMH201402 */
#endif    /* STD_ON == COM_FILTER_ENABLE */



#endif    /* PC_Veriant */



/*=======[E X T E R N A L   F U N C T I O N   D E C L A R A T I O N S]========*/
/******************************************************************************/
/*
 * Brief               This service initializes internal and external interfaces
 *                     and variables of the AUTOSAR COM layer for the further
 *                     processing. After calling this function the inter-ECU
 *                     communication is still disabled.
 * ServiceId           0x01
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant
 * Param-Name[in]      Config: Pointer to the COM configuration data.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_Init(P2CONST(Com_ConfigType, AUTOMATIC, COM_CONST_PBCFG) config);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               This service stops the inter-ECU communication. All started
 *                     I-PDU groups are stopped and have to be started again, if
 *                     needed, after Com_Init is called. By a call to ComDeInit COM
 *                     is put into an not initialized state.
 * ServiceId           0x02
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_DeInit(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Starts a preconfigured I-PDU group.
 * ServiceId           0x03
 * Sync/Async          Synchronous
 * Reentrancy          Reentrant for different I-PDU groups.
 *                     Non reentrant for the same I-PDU group.
 * Param-Name[in]      IpduGroupId: Id of I-PDU group to be started.
 *                     Initialize: Flag to request initialization of the data in
 *                     the data in the I-PDUs of this I-PDU group.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_IpduGroupStart(Com_PduGroupIdType IpduGroupId, boolean Initialize);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Stops a preconfigured I-PDU group.
 * ServiceId           0x04
 * Sync/Async          Synchronous
 * Reentrancy          Reentrant for different I-PDU groups.
 *                     Non reentrant for the same I-PDU group.
 * Param-Name[in]      IpduGroupId: Id of I-PDU group to be stopped.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Disables the reception deadline monitoring for the I-PDUs
 *                     within the given I-PDU group.
 * ServiceId           0x05
 * Sync/Async          Synchronous
 * Reentrancy          Reentrant for different I-PDU groups.
 *                     Non reentrant for the same I-PDU group.
 * Param-Name[in]      IpduGroupId: Id of I-PDU group where reception DM shall be
 *                     disabled.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_DisableReceptionDM(Com_PduGroupIdType IpduGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Enables the reception deadline monitoring for the I-PDUs
 *                     within the given I-PDU group.
 * ServiceId           0x06
 * Sync/Async          Synchronous
 * Reentrancy          Reentrant for different I-PDU groups.
 *                     Non reentrant for the same I-PDU group.
 * Param-Name[in]      IpduGroupId: Id of I-PDU group where reception DM shall be
 *                     enabled.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_EnableReceptionDM(Com_PduGroupIdType IpduGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Returns the status of the AUTOSAR COM module.
 * ServiceId           0x07
 * Sync/Async          Synchronous
 * Reentrancy          Reentrant
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              Com_StatusType: COM_UNINIT: AUTOSAR COM is not initialized
 *                                                 and not usable.
 *                                     COM_INIT: AUTOSAR COM is initialized and
 *                                               usable.
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(Com_StatusType, COM_CODE)
Com_GetStatus(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Provides the unique identifier of the configuration.
 * ServiceId           0x08
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint32: configured ConfigurationID.
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint32, COM_CODE)
Com_GetConfigurationId(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"


/******************************************************************************/
/*
 * Brief               The service Com_SendSignal updates the signal object identified
 *                     by SignalId with the signal referenced by the SignalDataPtr
 *                     parameter.
 * ServiceId           0x0a
 * Sync/Async          Asynchronous
 * Reentrancy          Non Reentrant for the same signal. Reentrant for different signals.
 * Param-Name[in]      SignalId: Id of Signal to be sent.
 *                     SignalDataPtr: Reference to the signal data to be transmitted.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_SendSignal
(
    Com_SignalIdType SignalId, 
    P2CONST(void, AUTOMATIC, COM_APPL_DATA) SignalDataPtr
);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               The service Com_ReceiveSignal updates the signal referenced
 *                     by SignalDataPtr with the data in the signal object identified
 *                     by SignalId.
 * ServiceId           0x0b
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant for the same signal. Reentrant for different signals.
 * Param-Name[in]      SignalId: Id of Signal to be received.
 * Param-Name[out]     SignalDataPtr: Reference to the signal data in which to store
 *                                    the received data.
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_ReceiveSignal
(
    Com_SignalIdType SignalId, 
    P2VAR(void, AUTOMATIC, COM_APPL_DATA) SignalDataPtr
);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"


/******************************************************************************/
/*
 * Brief               The service Com_UpdateShadowSignal updates a group signal
 *                     with the data, referenced by SignalDataPtr.
 * ServiceId           0x0c
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant for the same group signal. Reentrant for
 *                     different group signals.
 * Param-Name[in]      SignalId: Id of group signal to be updated.
 *                     SignalDataPtr: Reference to the group signal data to be updated.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_UpdateShadowSignal
(
    Com_SignalIdType SignalId, 
    P2CONST(void, AUTOMATIC, COM_APPL_DATA) SignalDataPtr
);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               The service Com_SendSignalGroup copies the content of the
 *                     associated shadow buffer to the associated I-PDU.
 * ServiceId           0x0d
 * Sync/Async          Asynchronous
 * Reentrancy          Non Reentrant for the same group signal. Reentrant for
 *                     different group signals.
 * Param-Name[in]      SignalGroupId: Id of signal group to be send.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               The service Com_ReceiveSignalGroup copies the received
 *                     signal group from the I-PDU to the shadow buffer.
 * ServiceId           0x0e
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant for the same group signal. Reentrant for
 *                     different group signals.
 * Param-Name[in]      SignalGroupId: Id of signal group to be received.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               The service Com_ReceiveShadowSignal updates the group signal
 *                     which is referenced by SignalDataPtr with the data in the
 *                     shadow buffer.
 * ServiceId           0x0f
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant for the same group signal. Reentrant for
 *                     different group signals.
 * Param-Name[in]      SignalId: Id of group signal to be received.
 * Param-Name[out]     SignalDataPtr: Reference to the group signal data in which
 *                                    to store the received data.
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_ReceiveShadowSignal
(
    Com_SignalIdType SignalId, 
    P2VAR(void, AUTOMATIC, COM_APPL_DATA) SignalDataPtr
);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Sender side AUTOSAR Software Component indicates via the RTE
 *                     to AUTOSAR COM that it is not able to provide a valid value
 *                     for the corresponding signal.
 * ServiceId           0x10
 * Sync/Async          Asynchronous
 * Reentrancy          Non Reentrant for the same signal. Reentrant for different signals.
 * Param-Name[in]      SignalId: Id of signal to be invalidated.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_InvalidateSignal(Com_SignalIdType SignalId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Sender side AUTOSAR Software Component indicates via the
 *                     RTE to AUTOSAR COM that it is not able to provide a valid
 *                     value for the corresponding group signal.
 * ServiceId           0x16
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant for the same signal. Reentrant for different signals.
 * Param-Name[in]      SignalId: Id of signal to be sent.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_InvalidateShadowSignal(Com_SignalIdType SignalId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Sender side AUTOSAR Software Component indicates via the RTE
 *                     to AUTOSAR COM that it is not able to provide a valid value
 *                     for the corresponding signal group.
 * ServiceId           0x1b
 * Sync/Async          Asynchronous
 * Reentrancy          Non Reentrant for the same signal group. Reentrant for different
 *                     signal groups.
 * Param-Name[in]      SignalGroupId: Id of signal group to be invalidated.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              uint8: E_OK: service has been accepted.
 *                            COM_SERVICE_NOT_AVAILABLE: corresponding I-PDU group was
 *                                                       stopped (or service failed
 *                                                       due to development error).
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(uint8, COM_CODE)
Com_InvalidateSignalGroup(Com_SignalGroupIdType SignalGroupId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               By a call to Com_TriggerIPDUSend the I-PDU with the given
 *                     ID is triggered for transmission.
 * ServiceId           0x17
 * Sync/Async          Synchronous
 * Reentrancy          Non Reentrant
 * Param-Name[in]      ComTxPduId: The I-PDU-ID if the I-PDU that shall be triggered
 *                                 for sending.
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By RTE
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_TriggerIPDUSend(PduIdType ComTxPduId);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               This function shall perform the processing of the AUTOSAR
 *                     COM receive processing that are not directly initiated by
 *                     the calls from the RTE and PDU-R.
 * ServiceId           0x18
 * Sync/Async          None
 * Reentrancy          None
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By Fixed_Cyclic Task
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_MainFunctionRx(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               This function shall perform the processing of the AUTOSAR
 *                     COM transmission activities that are not directly initiated
                       by the calls from the RTE and PDU-R.
 * ServiceId           0x19
 * Sync/Async          None
 * Reentrancy          None
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By Fixed_Cyclic Task
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_MainFunctionTx(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"

/******************************************************************************/
/*
 * Brief               Calls the signal gateway part of COM to forward received
 *                     signals to be routed. The insertion of this call is necessary
 *                     for decoupling receive interrupts and signal gateway tasks.
 * ServiceId           0x1a
 * Sync/Async          None
 * Reentrancy          None
 * Param-Name[in]      None
 * Param-Name[out]     None
 * Param-Name[in/out]  None
 * Return              None
 * PreCondition        None
 * CallByAPI           By Fixed_Cyclic Task
 */
/******************************************************************************/
#define COM_START_SEC_CODE
#include "Com_MemMap.h"
extern FUNC(void, COM_CODE)
Com_MainFunctionRouteSignals(void);
#define COM_STOP_SEC_CODE
#include "Com_MemMap.h"



/*=======[I N T E R N A L   D A T A]==========================================*/



/*=======[I N T E R N A L   F U N C T I O N   D E C L A R A T I O N S]========*/




#endif  /* end of COM_H */

/*=======[E N D   O F   F I L E]==============================================*/

